Okeee.... Prog notes:  What the fuck's up, mothafucka?

Opening: Print out a description of the program.  Prompt for "any key to continue..."

1) Draw out a layout of the board, a la the tictactoe input prog.  Then allow the the user to input the numbers of the first and last spots that he or she wants the h0rsey guy to visit.  Then pop up a query with the two spots clearly labeled, asking if that was okay?

2) Then process.....
     Starting at straight up, work your way around the current point, looking for a legal move.  Once a legal move is found, it's taken.  Then a check is made, to see whether the current square is the goal square.  If not, another move is made

EndGame: Print out each step of the path from first to last.  Ask the user if he or she wishes to repeat the onerous process.  If yes, reinitialize and return to step one.  If no, graciously thank the spankmeister for playing.

******************************************************************

Required functions for a knight's stroll:

This is only going to work for a (5X5) version of the game.  I'm not sure as to how to check for inability to reach a square.  I believe that it's possible to reach any square in a (5X5) board, therefore basing my work upon that assumption, I'm not going to write any checking routine.

void PathInput(int start, int finish);
// Purpose:   Input start and end points of a knight's stroll
// Requires:  Nothing
// Ensures:   The beginning and end points of the path are known
// Preserves: start, finish
// Alters:    None
// Produces:  None

******************************************************************

+----+----+----+----+----+
| 00 | 01 | 02 | 03 | 04 |   (0,0) (0,1) (0,2) (0,3) (0,4)
+----+----+----+----+----+
| 05 | 06 | 07 | 08 | 09 |   (1,0) (1,1) (1,2) (1,3) (1,4)
+----+----+----+----+----+
| 10 | 11 | 12 | 13 | 14 |   (2,0) (2,1) (2,2) (2,3) (2,4)
+----+----+----+----+----+
| 15 | 16 | 17 | 18 | 19 |   (3,0) (3,1) (3,2) (3,3) (3,4)
+----+----+----+----+----+
| 20 | 21 | 22 | 23 | 24 |   (4,0) (4,1) (4,2) (4,3) (4,4)
+----+----+----+----+----+

By these rules:
 if N = the number in the grid to the left
 N = (X*5)+Y
 N%5 = Y
 N/5 = X (in Borland C++, if the result for a division is a float, but it has to be stored in an int, then the number is rounded down ALWAYS)

Possible moves from any given point(clockwise from straight up):
#1: (X-2,Y+1) = (G,H)
#2: (X-1,Y+2) = (G,H)
#3: (X+1,Y+2) = (G,H)
#4: (X+2,Y+1) = (G,H)
#5: (X+2,Y-1) = (G,H)
#6: (X+1,Y-2) = (G,H)
#7: (X-1,Y-2) = (G,H)
#8: (X-2,Y-1) = (G,H)

A move is illegal if:
(G < 0)||(G > 4)||(H < 0)||(H > 4)
or if the spot has already been visited

if the move is legal:
#1: N - 9
#2: N - 3
#3: N + 7
#4: N + 11
#5: N + 9
#6: N + 3
#7: N - 7
#8: N - 11

******************************************************************

One possible method for creating a shorter path:
 Everytime that an attempted move is illegal because a spot has been visited, the number of the move to the occupied spot should be compared to the number of the current move, ie if we're making move #10 and we discover that we're adjacent to move #1.  If the spot isn't 2 moves less, ie if we hopped away and we're trying to hop back, then the incident and the move #'s in question can be recorded.  After the program reaches the lastspot, it can then backtrack using the incident log.  Using the first recorded incident(they can be stored in a queue), it can truncate the path(sounds complicated).
  This idea sounds complicated and therefore it's probably error-prone.  It's not integral to getting a good grade on the program therefore it won't be explored until the program is complete satisfactorily.  Implementation should include the ability for the user to specify whether or not he/she wishes for the program to explore truncation.  A simple flag variable in the program can keep track of whether or not to try.  The flag variable doesn't have to added to the program until implementation of the truncation routine('cuz that's not too difficult).